home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / msoftapp.zip / FILEWIN.CPP < prev    next >
C/C++ Source or Header  |  1993-06-01  |  10KB  |  436 lines
  1. // filewin.cpp : Defines the class behaviors for the application.
  2.  
  3. #include"viewer.h"
  4.  
  5. const SIZESTRING = 256;        // max characters in string
  6.  
  7. // CFileWin message map:
  8. BEGIN_MESSAGE_MAP(CFileWin, CMDIChildWnd)
  9.     ON_WM_CREATE()
  10.     ON_COMMAND(IDM_BLACK, OnColor)
  11.     ON_COMMAND(IDM_RED, OnColor)
  12.     ON_COMMAND(IDM_GREEN, OnColor)
  13.     ON_COMMAND(IDM_BLUE, OnColor)
  14.     ON_COMMAND(IDM_WHITE, OnColor)
  15.     ON_COMMAND(IDM_CUSTOM, OnColor)
  16.     ON_WM_PAINT()
  17.     ON_WM_HSCROLL()
  18.     ON_WM_VSCROLL()
  19.     ON_WM_DESTROY()
  20.     ON_WM_SIZE()
  21.     ON_WM_TIMER()
  22.     ON_WM_MDIACTIVATE()
  23.     ON_WM_KEYDOWN()
  24. END_MESSAGE_MAP()
  25.  
  26. CFileWin::CFileWin(void)
  27.     {
  28.     m_pMenuCurrent = NULL;
  29.     m_bWindowActive = FALSE;
  30.     m_pMyFile = NULL;
  31.     m_ColorID = IDM_BLACK;
  32.     m_TextColor = clrTextArray[0];
  33.     }
  34.  
  35. CFileWin::~CFileWin(void)
  36.        {
  37.     if(m_pMyFile != NULL)
  38.         {
  39.         m_pMyFile->Close();
  40.         delete m_pMyFile;
  41.            }
  42.     if(m_bWindowActive)
  43.         {
  44.         // Suppress Foundation DestroyMenu done in CMenu destructor 
  45.         //(Windows takes care of menu cleanup for the active window)
  46.         //
  47.         m_pMenuCurrent->Detach();
  48.            }
  49.        }
  50.  
  51. int CFileWin::OnCreate(LPCREATESTRUCT)
  52.     {
  53.     TEXTMETRIC tm;
  54.     CWindowDC dc(this);
  55.  
  56.     dc.SelectStockObject(SYSTEM_FIXED_FONT);
  57.     dc.GetTextMetrics(&tm);
  58.  
  59.     m_nCxChar = tm.tmAveCharWidth;
  60.     m_nCyChar = tm.tmHeight + tm.tmExternalLeading;
  61.  
  62.     m_nVScrollPos = 0;
  63.     m_nHScrollPos = 0;
  64.     m_lTopLine = 0L;
  65.  
  66.     SetScrollRange(SB_VERT, 0, SCROLLMAX, FALSE);
  67.     SetScrollRange(SB_HORZ, 0, SIZESTRING, FALSE);
  68.     SetWindowText(strFileTitle);
  69.     return 0;
  70.     }
  71.  
  72. void CFileWin::OnDestroy(void)
  73.        {
  74.     GetMDIFrame()->SendMessage(WM_CHILDDESTROY,(UINT)m_hWnd, 0);
  75.     }
  76.  
  77. // OnPaint
  78. void CFileWin::OnPaint(void)
  79.     {
  80.     char        acBuf[ SIZESTRING ];
  81.     CPaintDC    dc(this);
  82.     CRect       rect, rect2;
  83.     int         y;
  84.     char*       pc;
  85.  
  86.     GetClientRect(&rect);
  87.     dc.SetTextAlign(TA_LEFT);
  88.     dc.SelectStockObject(SYSTEM_FIXED_FONT);
  89.     dc.SetTextColor(m_TextColor); //::GetSysColor(COLOR_WINDOWTEXT));
  90.     dc.SetBkColor(::GetSysColor(COLOR_WINDOW));
  91.  
  92.     if(m_pMyFile != NULL)
  93.         {
  94.         TRY
  95.             {
  96.             m_pMyFile->Seek(m_lTopLine, CFile::begin);
  97.             }
  98.         CATCH(CFileException, e)
  99.             {
  100.             TRACE("Bad Seek in OnPaint %ld\n", m_lTopLine);
  101.             }
  102.         END_CATCH
  103.  
  104.         rect2.left  = rect.left;
  105.         rect2.right = rect.right;
  106.  
  107.         m_nLinesPainted = 0;
  108.         for(y = m_nCxChar/2; y < rect.bottom; y += m_nCyChar)
  109.             {
  110.             m_pMyFile->NextLine(acBuf, SIZESTRING);
  111.  
  112.             pc = acBuf;
  113.             if((int)strlen(acBuf) < m_nHScrollPos)
  114.                 *acBuf = 0;
  115.             else
  116.                 pc += m_nHScrollPos;
  117.  
  118.             rect2.top = y;
  119.             rect2.bottom = y + m_nCyChar;
  120.             dc.ExtTextOut(m_nCyChar/2, rect2.top, ETO_OPAQUE, &rect2,
  121.                            pc, strlen(pc), NULL);
  122.             m_nLinesPainted++;
  123.             }
  124.         }
  125.     }
  126.  
  127. // OnAbout:
  128. void CFileWin::OnAbout(void)
  129.     {
  130.     CDialog about("AboutBox", this);
  131.     about.DoModal();
  132.     }
  133.  
  134. // OnOpen:
  135. BOOL CFileWin::Open(void)
  136.     {
  137.     CString strFileName;
  138.  
  139.         // First close any open file
  140.     if(m_pMyFile != NULL)
  141.         {
  142.         m_pMyFile->Close();
  143.         delete m_pMyFile;
  144.         m_pMyFile = NULL;
  145.         SetWindowText("No File");
  146.         Invalidate(TRUE);
  147.         m_lTopLine = 0L;
  148.         m_nVScrollPos = 0;
  149.         SetScrollPos(SB_VERT, m_nVScrollPos, TRUE);
  150.         m_nHScrollPos = 0;
  151.         SetScrollPos(SB_HORZ, m_nHScrollPos, TRUE);
  152.         }
  153.  
  154.     BOOL success;
  155.     TRY
  156.         {
  157.         success = FileDlg(TRUE, SIZESTRING, 
  158.                 strFileName.GetBuffer(SIZESTRING),
  159.                 SIZESTRING, 
  160.                 strFileTitle.GetBuffer(SIZESTRING));
  161.         strFileName.ReleaseBuffer();
  162.         strFileTitle.ReleaseBuffer();
  163.  
  164.         if(success)
  165.             {
  166.                 // try to open the file here
  167.             m_pMyFile = new CLineFile(strFileName,
  168.                                         CFile::modeRead | CFile::typeBinary);
  169.             m_lFileSize = m_pMyFile->GetLength();
  170.  
  171.             // check to make sure it is a text file
  172.             BYTE byBuf[128];
  173.             for(int iby = m_pMyFile->Read(&byBuf, 128); --iby >= 0;)
  174.                 if(byBuf[iby] > 128)
  175.                     {
  176.                     m_pMyFile->Close();
  177.                     delete m_pMyFile;
  178.                     m_pMyFile = NULL;
  179.                     m_lFileSize = 0L;
  180.                     MessageBox("File contains non-printable characters", 
  181.                         "Error", MB_OK);
  182.                     return FALSE;
  183.                     }
  184.             m_pMyFile->SeekToBegin();
  185.             }
  186.         }
  187.     CATCH(CFileException, e)
  188.         {
  189.         char ErrorMsg[ 80 ];
  190.         sprintf(ErrorMsg,"Error 0x%lx opening %s.",
  191.                 e->m_lOsError, (const char*)strFileTitle);
  192.         MessageBox(ErrorMsg, "File Open Error");
  193.         }
  194.     END_CATCH
  195.     return success;
  196.     }
  197.  
  198. // OnVScroll:
  199. void CFileWin::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar*)
  200.     {
  201.     char        acBuf[SIZESTRING];
  202.     LONG        oldLine = m_lTopLine;
  203.     LONG        l;
  204.  
  205.     if(m_pMyFile == NULL)
  206.         return;
  207.  
  208.     TRY
  209.         {
  210.         switch(nSBCode)
  211.             {
  212.             case SB_LINEUP:
  213.                 if(m_lTopLine == 0L)
  214.                     break;
  215.                 m_pMyFile->SetBegin(m_lTopLine);
  216.                 m_lTopLine = m_pMyFile->BackLines(acBuf, SIZESTRING, 1);
  217.                 break;
  218.  
  219.             case SB_LINEDOWN:
  220.                 m_pMyFile->Seek(m_lTopLine, CFile::begin);
  221.                 m_lTopLine = m_pMyFile->NextLine(acBuf, SIZESTRING);
  222.                 break;
  223.  
  224.             case SB_PAGEUP:
  225.                 if(m_lTopLine == 0L)
  226.                     break;
  227.                 m_pMyFile->SetBegin(m_lTopLine);
  228.                 m_lTopLine = m_pMyFile->BackLines(acBuf, SIZESTRING,
  229.                                                 m_nLinesPainted);
  230.                 break;
  231.  
  232.             case SB_PAGEDOWN:
  233.                 m_lTopLine = m_pMyFile->GetPosition();
  234.                 break;
  235.  
  236.             case SB_BOTTOM:
  237.                 nPos = 1000;
  238.                 goto ThumbGoTo;
  239.  
  240.             case SB_TOP:
  241.                 nPos = 0;
  242.                 // fall thru
  243.  
  244.             case SB_THUMBPOSITION:
  245. ThumbGoTo:
  246.                 m_nVScrollPos = nPos;
  247.                 if(m_lFileSize > 40000L)
  248.                     l =(m_lFileSize / 1000L) * nPos;
  249.                 else
  250.                     l =(m_lFileSize * nPos) / 1000L;
  251.  
  252.                 m_lTopLine = m_pMyFile->LineNear(acBuf, SIZESTRING, l);
  253.                 break;
  254.  
  255.             default:
  256.                 return;
  257.             }
  258.         }
  259.     CATCH(CFileException, e)
  260.         {
  261.         TRACE("Bad Seek in OnVScroll\n");
  262.         m_lTopLine = 0L;
  263.         }
  264.     END_CATCH
  265.  
  266.     if(m_lTopLine < 0L)
  267.         m_lTopLine = 0L;
  268.  
  269.     if(m_lFileSize > 40000)
  270.         m_nVScrollPos =(short)(m_lTopLine  /(m_lFileSize / 1000L));
  271.     else
  272.         m_nVScrollPos =(short)(m_lTopLine * 1000L / m_lFileSize);
  273.  
  274.     if(m_nVScrollPos < 0)
  275.         m_nVScrollPos = 0;
  276.     if(m_nVScrollPos > SCROLLMAX)
  277.         m_nVScrollPos = SCROLLMAX;
  278.  
  279.     SetScrollPos(SB_VERT, m_nVScrollPos, TRUE);
  280.  
  281.     if(m_lTopLine != oldLine)
  282.         Invalidate(FALSE);
  283.     }
  284.  
  285. // OnHScroll:
  286. void CFileWin::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar*)
  287.     {
  288.     if(m_pMyFile == NULL)
  289.         return;
  290.  
  291.     switch(nSBCode)
  292.         {
  293.         case SB_LINEUP:
  294.             m_nHScrollPos -= 1;
  295.             break;
  296.  
  297.         case SB_LINEDOWN:
  298.             m_nHScrollPos += 1;
  299.             break;
  300.  
  301.         case SB_PAGEUP:
  302.             m_nHScrollPos -= 10;
  303.             break;
  304.  
  305.         case SB_PAGEDOWN:
  306.             m_nHScrollPos += 10;
  307.             break;
  308.  
  309.         case SB_TOP:
  310.             nPos = 0;
  311.             // fall thru
  312.         case SB_THUMBPOSITION:
  313.             m_nHScrollPos = nPos;
  314.             break;
  315.  
  316.         default:
  317.             return;
  318.         }
  319.  
  320.     if(m_nHScrollPos < 0)
  321.         m_nHScrollPos = 0;
  322.  
  323.     if(m_nHScrollPos > SIZESTRING)
  324.         m_nHScrollPos = SIZESTRING;
  325.  
  326.     SetScrollPos(SB_HORZ, m_nHScrollPos, TRUE);
  327.     Invalidate(FALSE);
  328.     }
  329.  
  330. // catch arrow keys and simulate touching scroll bars
  331. void CFileWin::OnKeyDown(UINT wChar, UINT /* nRepCnt */, UINT /* wFlags */)
  332.     {
  333.     switch(wChar)
  334.         {
  335.         case VK_HOME:
  336.             SendMessage(WM_VSCROLL, SB_TOP, 0L);
  337.             SendMessage(WM_HSCROLL, SB_TOP, 0L);
  338.             return;
  339.  
  340.         case VK_END:
  341.             SendMessage(WM_VSCROLL, SB_BOTTOM, 0L);
  342.             return;
  343.  
  344.         case VK_PRIOR:
  345.             SendMessage(WM_VSCROLL, SB_PAGEUP, 0L);
  346.             return;
  347.  
  348.         case VK_NEXT:
  349.             SendMessage(WM_VSCROLL, SB_PAGEDOWN, 0L);
  350.             return;
  351.  
  352.         case VK_UP:
  353.             SendMessage(WM_VSCROLL, SB_LINEUP, 0L);
  354.             return;
  355.  
  356.         case VK_DOWN:
  357.             SendMessage(WM_VSCROLL, SB_LINEDOWN, 0L);
  358.             return;
  359.  
  360.         case VK_RIGHT:
  361.             SendMessage(WM_HSCROLL, SB_LINEDOWN, 0L);
  362.             return;
  363.  
  364.         case VK_LEFT:
  365.             SendMessage(WM_HSCROLL, SB_LINEUP, 0L);
  366.             return;
  367.         }
  368.     }
  369.  
  370. BOOL CFileWin::FileDlg(BOOL bOpen, int nMaxFile, LPSTR szFile,
  371.         int nMaxFileTitle, LPSTR szFileTitle)
  372.     {
  373.     char szFilter[] = "Text Files(*.txt)|*.txt|All Files(*.*)|*.*||";
  374.     CFileDialog dlg(bOpen, "txt", szFile, OFN_HIDEREADONLY, szFilter);
  375.  
  376.     // This example shows how to access the OPENFILENAME struct
  377.     // directly.
  378.     dlg.m_ofn.lpstrFile = szFile;
  379.     dlg.m_ofn.lpstrFileTitle = szFileTitle;
  380.     dlg.m_ofn.nMaxFileTitle = nMaxFileTitle;
  381.     
  382.     return dlg.DoModal() == IDOK ? TRUE : FALSE;
  383.     }
  384.  
  385.  
  386. void CFileWin::OnMDIActivate(BOOL bActivate, CWnd*, CWnd*)
  387.     {
  388.     CMDIFrameWnd* pFrame = GetMDIFrame();
  389.     CMenu* pWinPopupMenu = NULL;
  390.     CMenu* pMenu = new CMenu;
  391.  
  392.     m_bWindowActive = bActivate;
  393.  
  394.     if(bActivate)
  395.         {
  396.         pMenu->LoadMenu("FileWin");
  397.         pWinPopupMenu = pMenu->GetSubMenu(FILEWIN_MENU_POS);
  398.         CMenu* pLastMenu = pFrame->MDISetMenu(pMenu, pWinPopupMenu);
  399.         pLastMenu->DestroyMenu();
  400.  
  401.         pMenu->CheckMenuItem(m_ColorID, bActivate ? MF_CHECKED : MF_UNCHECKED);
  402.         }
  403.     else
  404.         {
  405.         pMenu->LoadMenu("Init");
  406.         pWinPopupMenu = pMenu->GetSubMenu(INIT_MENU_POS);
  407.         CMenu* pLastMenu = pFrame->MDISetMenu(pMenu, pWinPopupMenu);
  408.         pLastMenu->DestroyMenu();
  409.         }
  410.     delete m_pMenuCurrent;
  411.     m_pMenuCurrent = pMenu;
  412.     pFrame->DrawMenuBar();
  413.     }
  414.  
  415.  
  416. // OnColor: Change menu checkmarks to indicate the newly selected color.
  417. void CFileWin::OnColor()
  418.     {
  419.     CMenu* pMenu = GetMDIFrame()->GetMenu();
  420.     pMenu->CheckMenuItem(m_ColorID, MF_UNCHECKED);
  421.  
  422.     m_ColorID = GetCurrentMessage()->wParam;
  423.     pMenu->CheckMenuItem(m_ColorID, MF_CHECKED);
  424.  
  425.     if(m_ColorID != IDM_CUSTOM)
  426.         m_TextColor = clrTextArray[m_ColorID - IDM_BLACK];
  427.     else
  428.         {
  429.         CColorDialog dlgColor(m_TextColor);
  430.         if(dlgColor.DoModal() == IDOK)
  431.             m_TextColor = dlgColor.GetColor();
  432.         }
  433.         // Force the client area text to be repainted in the new color
  434.     Invalidate();
  435.     }
  436.